//限制并发
// const pLimit = require('p-limit');
const pTry = (fn, ...arguments_) => new Promise(resolve => {
  resolve(fn(...arguments_));
});

const pLimit = concurrency => {
  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
    return Promise.reject(new TypeError('Expected `concurrency` to be a number from 1 and up'));
  }

  const queue = [];
  let activeCount = 0;

  const next = () => {
    activeCount--;

    if (queue.length > 0) {
      queue.shift()();
    }
  };

  const run = (fn, resolve, ...args) => {
    activeCount++;

    const result = pTry(fn, ...args);

    resolve(result);

    result.then(next, next);
  };

  const enqueue = (fn, resolve, ...args) => {
    if (activeCount < concurrency) {
      run(fn, resolve, ...args);
    } else {
      queue.push(run.bind(null, fn, resolve, ...args));
    }
  };

  const generator = (fn, ...args) => {
    return new Promise(resolve => {
      return enqueue(fn, resolve, ...args);
    });
  };
  Object.defineProperties(generator, {
    activeCount: {
      get: () => activeCount
    },
    pendingCount: {
      get: () => queue.length
    }
  });

  return generator;
};

const limit = pLimit(1);

const sleep = function (time) {
  return new Promise((resolve => {
    setTimeout(resolve, time);
  }));
};

const func1 = async function () {
  console.log('---func1');
  await sleep(1000);
};

const func2 = async function () {
  console.log('---func2');
  await sleep(1000);
};

const func3 = async function () {
  console.log('---func3');
  await sleep(1000);
};

// const input = [
//   func1(),
//   func2(),
//   func3(),
// ];

const input = [
  limit(func1),
  limit(func2),
  limit(func3),
];

(async () => {
  const result = await Promise.all(input);
  console.log(result);
})();
